/**
 * 评论控制器
 * @module controllers/commentController
 */

const { Comment, Article } = require('../models');

/**
 * 获取文章评论
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @returns {Object} 响应对象
 */
const getArticleComments = async (req, res) => {
  try {
    const { articleId } = req.params;
    
    // 检查文章是否存在
    const article = await Article.findByPk(articleId);
    if (!article) {
      return res.status(404).json({ message: '文章不存在' });
    }
    
    // 查询评论
    const comments = await Comment.findAll({
      where: { 
        articleId,
        approved: true // 只返回已审核的评论
      },
      order: [['createdAt', 'DESC']]
    });
    
    return res.status(200).json({ comments });
  } catch (error) {
    console.error('获取评论错误:', error);
    return res.status(500).json({ message: '服务器错误' });
  }
};

/**
 * 创建评论
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @returns {Object} 响应对象
 */
const createComment = async (req, res) => {
  try {
    const { articleId } = req.params;
    const { username, email, content } = req.body;
    
    // 验证请求体
    if (!username || !email || !content) {
      return res.status(400).json({ message: '用户名、邮箱和内容不能为空' });
    }
    
    // 检查文章是否存在
    const article = await Article.findByPk(articleId);
    if (!article) {
      return res.status(404).json({ message: '文章不存在' });
    }
    
    // 创建评论
    const comment = await Comment.create({
      articleId,
      username,
      email,
      content,
      approved: false // 默认未审核
    });
    
    return res.status(201).json({ 
      message: '评论提交成功，等待审核',
      comment: {
        id: comment.id,
        username: comment.username,
        content: comment.content,
        createdAt: comment.createdAt
      }
    });
  } catch (error) {
    console.error('创建评论错误:', error);
    return res.status(500).json({ message: '服务器错误' });
  }
};

/**
 * 获取所有评论(管理员)
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @returns {Object} 响应对象
 */
const getAllComments = async (req, res) => {
  try {
    const { approved } = req.query;
    
    // 构建查询条件
    const where = {};
    if (approved !== undefined) {
      where.approved = approved === 'true';
    }
    
    // 查询评论
    const comments = await Comment.findAll({
      where,
      include: [
        { model: Article, as: 'article', attributes: ['id', 'title'] }
      ],
      order: [['createdAt', 'DESC']]
    });
    
    return res.status(200).json({ comments });
  } catch (error) {
    console.error('获取所有评论错误:', error);
    return res.status(500).json({ message: '服务器错误' });
  }
};

/**
 * 审核评论
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @returns {Object} 响应对象
 */
const approveComment = async (req, res) => {
  try {
    const { id } = req.params;
    const { approved } = req.body;
    
    // 查找评论
    const comment = await Comment.findByPk(id);
    if (!comment) {
      return res.status(404).json({ message: '评论不存在' });
    }
    
    // 更新评论
    await comment.update({ approved });
    
    return res.status(200).json({ 
      message: approved ? '评论已审核通过' : '评论已拒绝',
      comment
    });
  } catch (error) {
    console.error('审核评论错误:', error);
    return res.status(500).json({ message: '服务器错误' });
  }
};

/**
 * 删除评论
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 * @returns {Object} 响应对象
 */
const deleteComment = async (req, res) => {
  try {
    const { id } = req.params;
    
    // 查找评论
    const comment = await Comment.findByPk(id);
    if (!comment) {
      return res.status(404).json({ message: '评论不存在' });
    }
    
    // 删除评论
    await comment.destroy();
    
    return res.status(200).json({ message: '评论删除成功' });
  } catch (error) {
    console.error('删除评论错误:', error);
    return res.status(500).json({ message: '服务器错误' });
  }
};

module.exports = {
  getArticleComments,
  createComment,
  getAllComments,
  approveComment,
  deleteComment
}; 